;;; Upper CYC(R) Ontology flat-file ;;; Copyright Cycorp 1997. All rights reserved. ;;;Cycorp License Agreement ;;;Cycorp is providing this material from the Cyc(tm) Upper ;;;Ontology at no charge, for everyone to use, including ;;;commercial service use and incorporation into products. ;;;However, it is not 'Public Domain.' Please acknowledge ;;;Cycorp, 3721 Executive Center Dr., Austin, TX 78731 in ;;;any use or citation of this material, and request that each ;;;further user include a full copy of this notice as well, ;;;in any use or citation they make of the material. All ;;;these terms equally apply to renamings and other ;;;logically equivalent reformulations of the material in ;;;any natural or formal language. Cycorp intends to ;;;amend and expand the material from time to time; the ;;;latest version is available at http://www.cyc.com ;;; #$oppositeAttributeValue (#$isa #$oppositeAttributeValue #$AntiTransitiveBinaryPredicate) (#$isa #$oppositeAttributeValue #$SymmetricBinaryPredicate) (#$genlPreds #$oppositeAttributeValue #$negationAttribute) (#$genlInverse #$oppositeAttributeValue #$oppositeAttributeValue) (#$arg1Isa #$oppositeAttributeValue #$AttributeValue) (#$arg2Isa #$oppositeAttributeValue #$AttributeValue) (#$comment #$oppositeAttributeValue "(#$oppositeAttributeValue ATT1 ATT2) means that ATT2 is the opposite of ATT1. E.g., #$DeviceOn and #$DeviceOff.") ;;; #$oppositeDirection-Interval (#$not (#$isa #$oppositeDirection-Interval #$TransitiveBinaryPredicate)) (#$isa #$oppositeDirection-Interval #$SymmetricBinaryPredicate) (#$isa #$oppositeDirection-Interval #$AntiTransitiveBinaryPredicate) (#$isa #$oppositeDirection-Interval #$SpatialPredicate) (#$genlPreds #$oppositeDirection-Interval #$oppositeAttributeValue) (#$genlInverse #$oppositeDirection-Interval #$oppositeDirection-Interval) (#$arg1Isa #$oppositeDirection-Interval #$UnitVectorInterval) (#$arg2Isa #$oppositeDirection-Interval #$UnitVectorInterval) (#$comment #$oppositeDirection-Interval "(#$oppositeDirection-Interval COMING GOING) means that the vector which points in the opposite direction to the vector COMING is the vector GOING. More technically, COMING and GOING are both elements of #$UnitVectorInterval in Cyc's spatial representation, and the midpoint of the direction interval COMING is 180 degrees from the midpoint of the direction interval GOING. Examples: (#$oppositeDirection-Interval #$North-Generally #$South-Generally), (#$oppositeDirection-Interval #$DorsalDirection #$VentralDirection). If a precise opposite direction is needed, use #$oppositeDirection-Precise.") ;;; #$oppositeDirection-Precise (#$not (#$isa #$oppositeDirection-Precise #$TransitiveBinaryPredicate)) (#$isa #$oppositeDirection-Precise #$SymmetricBinaryPredicate) (#$isa #$oppositeDirection-Precise #$AntiTransitiveBinaryPredicate) (#$genlPreds #$oppositeDirection-Precise #$oppositeDirection-Interval) (#$genlInverse #$oppositeDirection-Precise #$oppositeDirection-Precise) (#$arg1Isa #$oppositeDirection-Precise #$Vector-Precise) (#$arg2Isa #$oppositeDirection-Precise #$Vector-Precise) ;;; #$or (#$isa #$or #$LogicalConnective) (#$isa #$or #$CommutativeRelation) (#$isa #$or #$VariableArityRelation) (#$argsIsa #$or #$CycFormula) (#$comment #$or "The predicate #$or is the disjunction relation in Cyc. #$or is a variable-arity relation and takes any number of elements of #$CycFormula as its arguments. (#$or P Q ... Z) is true if at least one of the formulas P, Q, ..., or Z is true in Cyc.") (#$resultIsa #$or #$CycExpression) ;;; #$orientation (#$isa #$orientation #$SpatialPredicate) (#$isa #$orientation #$BinaryPredicate) (#$arg1Isa #$orientation #$PartiallyTangible) (#$arg2Isa #$orientation #$OrientationAttribute) (#$comment #$orientation "(#$orientation OBJECT ORTN) means that the tangible OBJECT is oriented in the way described by the #$OrientationAttribute ORTN. Examples: (#$orientation OBJ #$RightSideUp), (#$orientation OBJ #$VerticalOrientation). #$orientation is asserted with respect to the current context's #$FrameOfReference.") ;;; #$origin-RoundTrip (#$isa #$origin-RoundTrip #$IrreflexiveBinaryPredicate) (#$isa #$origin-RoundTrip #$AsymmetricBinaryPredicate) (#$isa #$origin-RoundTrip #$ActorSlot) (#$genlPreds #$origin-RoundTrip #$nonDeliberateActors) (#$genlPreds #$origin-RoundTrip #$toLocation) (#$genlPreds #$origin-RoundTrip #$fromLocation) (#$arg1Isa #$origin-RoundTrip #$Translation-RoundTrip) (#$arg2Isa #$origin-RoundTrip #$PartiallyTangible) (#$comment #$origin-RoundTrip "(#$origin-RoundTrip TRIP PLACE) means that the #$Translation-RoundTrip event TRIP leaves from and returns to the location PLACE. PLACE is both the #$fromLocation and #$toLocation of the entire TRIP, considered as a whole. For example, some commuters to Manhattan leave and return each day to #$Connecticut-State, which is their #$origin-RoundTrip. See also #$destination-RoundTrip.") ;;; #$orthography (#$isa #$orthography #$BinaryPredicate) (#$arg1Isa #$orthography #$Language) (#$arg2Isa #$orthography #$CommunicationConvention) (#$comment #$orthography "(#$orthography ?LANG ?WRIT) means that the #$WritingSystem ?WRIT is the usual mode of writing used to encode the #$Language ?LANG; that it is used by most of the people who customarily engage in writing ?LANG.") ;;; #$outputs (#$isa #$outputs #$ActorSlot) (#$genlPreds #$outputs #$postActors) (#$genlPreds #$outputs #$actors) (#$arg1Isa #$outputs #$CreationOrDestructionEvent) (#$arg2Isa #$outputs #$SomethingExisting) (#$comment #$outputs "The predicate #$outputs is used to relate a particular event to any of the outputs from that event. (#$outputs EVENT OBJECT) means that OBJECT is an output from the #$CreationOrDestructionEvent EVENT; i.e., OBJECT is either created as a result of EVENT, or it is something left after another thing was destroyed in EVENT. For example, silicon chips are #$outputsCreated in a chip manufacturing process, while scrap metal is #$outputsRemaining after cars are put through a crusher. Note that those two types of cases should be distinguished by using (respectively) the specialized predicates #$outputsCreated or #$outputsRemaining whenever they are appropriate, rather than only the more general predicate #$outputs.") ;;; #$outputsCreated (#$isa #$outputsCreated #$ActorSlot) (#$genlPreds #$outputsCreated #$outputs) (#$genlPreds #$outputsCreated #$nonDeliberateActors) (#$genlPreds #$outputsCreated #$startsDuring) (#$arg1Isa #$outputsCreated #$CreationEvent) (#$arg2Isa #$outputsCreated #$SomethingExisting) (#$comment #$outputsCreated "The predicate #$outputsCreated is used to identify items created by a particular event. (#$outputsCreated EVENT OBJECT) means that OBJECT doesn't exist before EVENT but comes into existence sometime during EVENT, as a result of EVENT. #$outputsCreated is a specialization of #$nonDeliberateActors, since it would in general be impossible for OBJECT to act deliberately in its own creation.") ;;; #$outputsRemaining (#$isa #$outputsRemaining #$IrreflexiveBinaryPredicate) (#$isa #$outputsRemaining #$AsymmetricBinaryPredicate) (#$isa #$outputsRemaining #$ActorSlot) (#$genlPreds #$outputsRemaining #$outputs) (#$genlPreds #$outputsRemaining #$preActors) (#$arg1Isa #$outputsRemaining #$DestructionEvent) (#$arg2Isa #$outputsRemaining #$SomethingExisting) (#$comment #$outputsRemaining "The predicate #$outputsRemaining is used to identify leftovers which survive from the #$inputs to a particular event. (#$outputsRemaining EVENT OBJECT) means that OBJECT persists after EVENT, and that it existed before EVENT as an identifiable part of one of the things destroyed during EVENT (see #$inputsDestroyed). Examples: (1) when a sheet of plywood is sawn through in a cutting event, the original board is destroyed and the #$outputsRemaining are the two smaller plywood pieces; (2) after a #$FiltrationProcess, the #$suspendedPart and the #$suspendingFluid are the #$outputsRemaining from the original mixture which has been destroyed.") ;;; #$overlappingExternalConcept (#$isa #$overlappingExternalConcept #$TernaryPredicate) (#$arg1Isa #$overlappingExternalConcept #$Thing) (#$arg2Isa #$overlappingExternalConcept #$IndexedInfoSource) (#$arg3Isa #$overlappingExternalConcept #$CharacterString) (#$comment #$overlappingExternalConcept "(#$overlappingExternalConcept ?TERM ?SOURCE ?STRING) means that the Cyc concept ?TERM overlaps semantically with the concept named by ?STRING in the external data source ?SOURCE.") ;;; #$overlapsStart (#$isa #$overlapsStart #$ComplexTemporalRelation) (#$isa #$overlapsStart #$AsymmetricBinaryPredicate) (#$not (#$isa #$overlapsStart #$TransitiveBinaryPredicate)) (#$genlPreds #$overlapsStart #$endsDuring) (#$genlInverse #$overlapsStart #$startsDuring) (#$arg1Isa #$overlapsStart #$TemporalThing) (#$arg2Isa #$overlapsStart #$TemporalThing) (#$comment #$overlapsStart "(#$overlapsStart FIRST SECOND) means that FIRST starts before SECOND and ends during SECOND. That is, the #$startingPoint of FIRST is before the #$startingPoint of SECOND, and the #$endingPoint of FIRST is before the #$endingPoint of SECOND. So this is actually a STRONGER relation than might be suggested just by its name alone, since the name alone does not suggest that FIRST must end during SECOND. If all you mean to say, in some situation, is that FIRST starts before SECOND, then do NOT use #$overlapsStart; just use the #$startsAfterStartingOf relation; i.e., say (#$startsAfterStartingOf SECOND FIRST). Also note that #$overlapsStart is, in a way, a WEAKER relation than might be suggested by its name alone. Namely, the #$startingPoint of SECOND might not even be a point of FIRST (if FIRST is discontinuous). Note: This Cyc temporal relation is equivalent to what James Allen independently dubbed the OVERLAPS relation.") ;;; #$overrides (#$isa #$overrides #$TransitiveBinaryPredicate) (#$isa #$overrides #$AsymmetricBinaryPredicate) (#$isa #$overrides #$MetaKnowledgePredicate) (#$arg1Isa #$overrides #$Assertion) (#$arg2Isa #$overrides #$Assertion) (#$comment #$overrides "The predicate #$overrides is used to tell Cyc which rule to prefer when it encounters two conflicting rules while reasoning with default assertions. (#$overrides FIRST SECOND) means that if the assertions FIRST and SECOND both appear in conflicting arguments for and against some proposition, favor the argument that contains FIRST.") ;;; #$owns (#$isa #$owns #$CotemporalObjectsSlot) (#$isa #$owns #$AsymmetricBinaryPredicate) (#$not (#$isa #$owns #$TransitiveBinaryPredicate)) (#$not (#$isa #$owns #$ReflexiveBinaryPredicate)) (#$genlPreds #$owns #$hasOwnershipIn) (#$genlPreds #$owns #$cotemporal) (#$arg1Isa #$owns #$Agent) (#$arg2Isa #$owns #$SomethingExisting) (#$comment #$owns "(#$owns AGENT OBJECT) means that AGENT owns OBJECT -- that is, AGENT enjoys #$FullUseRights (q.v.) over OBJECT. Note: There are commonsense rules relating #$owns to #$controls. E.g., ownership typically implies control. But they are just default rules, as there are many exceptions (e.g., when the owner of a building leases it to a company for ten years, the owner gives up almost all `control' over it during that decade).") (#$synonymousExternalConcept #$owns #$SENSUS-Information1997 "OWNERSHIP") ;;; #$ownsShare (#$isa #$ownsShare #$TernaryPredicate) (#$arg1Isa #$ownsShare #$Agent) (#$arg2Isa #$ownsShare #$SomethingExisting) (#$arg3Isa #$ownsShare #$NonNegativeNumber) (#$comment #$ownsShare "The predicate #$ownsShare is used to state how much of some thing is owned by a particular #$Agent. (#$ownsShare AGENT SOMETHING SHARE) means that the #$Agent AGENT has SHARE #$Percent (q.v.) ownership of the object or company SOMETHING. Note that SHARE is a percentage and does not refer directly to a number of shares of #$Stock.") ;;; #$parallelObjects (#$isa #$parallelObjects #$ReflexiveBinaryPredicate) (#$isa #$parallelObjects #$TransitiveBinaryPredicate) (#$isa #$parallelObjects #$SymmetricBinaryPredicate) (#$isa #$parallelObjects #$SpatialPredicate) (#$genlInverse #$parallelObjects #$parallelObjects) (#$arg1Isa #$parallelObjects #$SpatialThing) (#$arg2Isa #$parallelObjects #$SpatialThing) (#$comment #$parallelObjects "(#$parallelObjects OBJ1 OBJ2) means that both OBJ1 and OBJ2 have a lengthwise axis, and those axes are parallel to each other.") ;;; #$parallelVectors (#$isa #$parallelVectors #$TransitiveBinaryPredicate) (#$isa #$parallelVectors #$ReflexiveBinaryPredicate) (#$isa #$parallelVectors #$SymmetricBinaryPredicate) (#$genlInverse #$parallelVectors #$parallelVectors) (#$arg1Isa #$parallelVectors #$VectorInterval) (#$arg2Isa #$parallelVectors #$VectorInterval) (#$comment #$parallelVectors "(#$parallelVectors VECTOR1 VECTOR2) means that VECTOR1 is parallel to VECTOR2.") ;;; #$parentActors (#$isa #$parentActors #$IrreflexiveBinaryPredicate) (#$isa #$parentActors #$AsymmetricBinaryPredicate) (#$isa #$parentActors #$ActorSlot) (#$genlPreds #$parentActors #$preActors) (#$arg1Isa #$parentActors #$BiologicalProductionEvent) (#$arg2Isa #$parentActors #$BiologicalLivingObject) (#$comment #$parentActors "(#$parentActors EV P) means that organism P is one of the parents in the #$BiologicalReproductionEvent EV.") ;;; #$parentCompany (#$isa #$parentCompany #$BinaryPredicate) (#$arg1Isa #$parentCompany #$Organization) (#$arg2Isa #$parentCompany #$Business) (#$comment #$parentCompany "The predicate #$parentCompany relates an organization to the business which is its parent company. (#$parentCompany ORG1 ORG2) means that ORG1 is a (partly or wholly owned) subsidiary of ORG2. ORG2 is the parent company that owns and substantially controls ORG1. E.g., (#$parentCompany TheLAWeekly TheVillageVoice).") ;;; #$partitionedInto (#$isa #$partitionedInto #$TaxonomicSlot) (#$genlPreds #$partitionedInto #$covering) (#$arg1Isa #$partitionedInto #$SetOrCollection) (#$arg2Isa #$partitionedInto #$DisjointSetOrCollection) (#$comment #$partitionedInto "(#$partitionedInto SETORCOL PART) means that the mathematical set or collection PART is a partition of the mathematical set or collection SETORCOL -- that is, the elements of PART are themselves mathematical sets or collections, and every element of SETORCOL is an element of exactly one element of PART, and every element of PART is a subset of SETORCOL. Or to put it another way, PART is a set or collection of disjoint sets or collections whose union is co-extensional with SETORCOL. Typically, the #$DisjointSetOrCollection that plays the role of PART in an assertion about partitioning will be a set specified by enumerating its elements, using the function #$ThePartition. (This is a special #$ReifiableFunction whose principal reason-for-being is to facilitate the inference heuristics associated with assertions about partitioning.)") ;;; #$parts (#$isa #$parts #$PartPredicate) (#$isa #$parts #$TransitiveBinaryPredicate) (#$isa #$parts #$AntiSymmetricBinaryPredicate) (#$isa #$parts #$ReflexiveBinaryPredicate) (#$genlPreds #$parts (#$MeaningInSystemFn #$SENSUS-Information1997 "GENERALIZED-POSSESSION")) (#$arg1Isa #$parts #$Individual) (#$arg2Isa #$parts #$Individual) (#$comment #$parts "(#$parts WHOLE PART) means that #$Individual PART is a part of #$Individual WHOLE. This predicate is very general. It can be used to refer to concepts including #$physicalParts, #$subEvents, #$timeSlices, and #$groupMembers.") ;;; #$passengers (#$isa #$passengers #$ActorSlot) (#$isa #$passengers #$AsymmetricBinaryPredicate) (#$isa #$passengers #$IrreflexiveBinaryPredicate) (#$genlPreds #$passengers #$transportees) (#$arg1Isa #$passengers #$TransportationEvent) (#$arg2Isa #$passengers #$Person) (#$comment #$passengers "(#$passengers MOVE PAS) means that PAS is a human #$transportees in MOVE who is not a #$driverActor for any #$subEvents of Move. Any PAS is not a #$driverActor for any #$subEvents of MOVE. PAS is likely to be sitting (see #$SittingPosture) during the MOVE.") ;;; #$pastTense (#$isa #$pastTense #$IntangibleObjectPredicate) (#$isa #$pastTense #$BinaryPredicate) (#$arg1Isa #$pastTense #$EnglishWord) (#$arg2Isa #$pastTense #$CharacterString) (#$comment #$pastTense "(#$pastTense WORD STRING) means that STRING is the past tense verb form of WORD. The regular past tense form is formed from the infinitive verb form with an `-ed' suffix. Verbs in the Cyc lexicon will have a #$pastTense entry only if they are irregular. Regular forms are generated by the morphology component. Regular example: `helped'. Irregular example: `ate'.") ;;; #$pathBetween (#$isa #$pathBetween #$TernaryPredicate) (#$arg1Isa #$pathBetween #$Path-Simple) (#$arg2Isa #$pathBetween #$Thing) (#$arg3Isa #$pathBetween #$Thing) (#$comment #$pathBetween "(#$pathBetween PATH X Y) means that the #$Path-Simple PATH goes between points (or places) X and Y, where X and Y do not 'overlap', and no further. Both X and Y have to be on PATH (see #$pointOnPath). Note that (#$pathBetween PATH X Y) is more specific than (#$pathConnects PATH X Y) because here the PATH cannot extend beyond X and Y. Within a particular #$PathSystem, a path's end points in the system are unique, and #$pathBetweenInSystem is restricted to paths and points in the system. When considered without a context of a path system, a path may have several different places at one end, such as Austin and Texas both being at the same end of some path along Highway I-35.") ;;; #$pathConnects (#$isa #$pathConnects #$TernaryPredicate) (#$isa #$pathConnects #$SpatialPredicate) (#$arg1Isa #$pathConnects #$Path-Simple) (#$arg2Isa #$pathConnects #$SpatialThing) (#$arg3Isa #$pathConnects #$SpatialThing) (#$comment #$pathConnects "(#$pathConnects PATH HERE THERE) means that PATH is an individual element of #$Path-Simple that connects HERE and THERE. Often PATH is a physical path or connection along which objects or information capable of using that path may travel, back and forth, between HERE and THERE. Note that (#$pathConnects ?PATH ?A ?B) doesn't mean that PATH cant't extend beyond ?A and ?B (in contrast with #$pathBetween ?A ?B).") ;;; #$pathTerminus (#$isa #$pathTerminus #$BinaryPredicate) (#$arg1Isa #$pathTerminus #$Path-Simple) (#$arg2Isa #$pathTerminus #$PartiallyTangible) (#$comment #$pathTerminus "#$pathTerminus (PATH END) means that END is a terminating end of a #$Path-Customary PATH, and that there are no further paths of the same type issuing from END. The terminal end of any #$Path-Customary may be a dead-end, closed off path end, or it may be open, or it may be a terminus of motion; it is not generally a #$JunctionOfPaths with one or more paths of the same basic type issuing beyond it. Contrast this with the predicate #$deadEndInSystem that indicates a terminus with respect to a specified #$PathSystem only.") ;;; #$pathway-Complete (#$isa #$pathway-Complete #$ActorSlot) (#$isa #$pathway-Complete #$FunctionalSlot) (#$genlPreds #$pathway-Complete #$pathway-Partial) (#$arg1Isa #$pathway-Complete #$Movement-TranslationEvent) (#$arg2Isa #$pathway-Complete #$Path-Generic) (#$comment #$pathway-Complete "The predicate #$pathway-Complete is used to indicate the whole route travelled by a moving object in a particular event. (#$pathway-Complete MOVE PATH) means that PATH is the entire trajectory along which an #$objectMoving travels in the #$Movement-TranslationEvent MOVE. There is exactly one #$pathway-Complete if (and only if) MOVE is an element of #$Translation-SinglePath. If MOVE is an element of #$Translation-MultiPath, then there are at least two #$pathway-Completes; i.e., at least two distinct values of PATH such that (#$pathway-Complete MOVE PATH) is true. PATH may be a marked or unmarked #$Path-Generic (q.v.). By definition, the #$pathway-Complete of a #$Movement-TranslationEvent connects the starting and stopping points (#$fromLocation, #$toLocation) of the whole movement event. (See also #$pathConnects.) Use #$pathwayPassesThrough to state that an object passes through a particular location on the #$Path-Generic. Note: Compare #$pathway-Complete with #$pathway-Partial; the former refers to the entire route of a particular #$Translation-Complete. A sub-region of a #$pathway-Complete is NOT itself considered a #$pathway-Complete of the same movement event; i.e., if (#$pathway-Complete MOVE PATH) is true, and we cut PATH up into ten pieces PATH1, ..., PATH10, then it will generally not be true that (#$pathway-Complete MOVE PATH8), but it will be true that (#$pathway-Partial MOVE PATH8).") (#$synonymousExternalConcept #$pathway-Complete #$SENSUS-Information1997 "PATH") ;;; #$pathway-Partial (#$isa #$pathway-Partial #$ActorSlot) (#$genlPreds #$pathway-Partial #$eventOccursAt) (#$genlPreds #$pathway-Partial #$temporallyIntersects) (#$arg1Isa #$pathway-Partial #$Movement-TranslationEvent) (#$arg2Isa #$pathway-Partial #$Path-Generic) (#$comment #$pathway-Partial "(pathway-Partial EVENT PATH) means that EVENT is a movement along a trajectory (see #$pathway-Complete) which has a sub-path in common with a sub-path of PATH. For example, if a certain trip to Dallas from Austin is via highway I-35, that does not mean either that the whole journey is along I-35 (it also may be along driveways and side streets), or that it is along all of I-35 (which would take you from the Mexican border all the way to the Canadian border). A part of the journey is along a part of I-35. This is in contrast to #$pathway-Complete, which relates a movement to its entire path.") ;;; #$pathwayPassesThrough (#$isa #$pathwayPassesThrough #$ActorSlot) (#$genlPreds #$pathwayPassesThrough #$nonDeliberateActors) (#$arg1Isa #$pathwayPassesThrough #$Translation-SinglePath) (#$arg2Isa #$pathwayPassesThrough #$PartiallyTangible) (#$comment #$pathwayPassesThrough "(#$pathwayPassesThrough MOVE LOC) means that the #$pathway-Complete of MOVE, which is an instance of #$Translation-SinglePath, passes through LOC, which is an instance of #$PartiallyTangible, and thus can be a location, a river or another path, etc. More formally, any #$objectMoving which undergoes motion from the #$fromLocation to the #$toLocation passes through LOC. Here `passes through LOC' means that OBJ both arrives and leaves LOC. Thus, LOC can not be a super region of any #$fromLocation nor any #$toLocations of MOVE. Otherwise it would be possible to state (#$pathwayPassesThrough TripToTheStore01 TheUniverse). On the other hand, LOC can be a sub region of some #$toLocation or some #$fromLocation.") ;;; #$perceives (#$isa #$perceives #$PerceivingSlot) (#$arg1Isa #$perceives #$PerceptualAgent) (#$arg2Isa #$perceives #$SpatialThing) (#$arg2Isa #$perceives #$TemporalThing) (#$comment #$perceives "(#$perceives AGENT OBJ) means that AGENT has come to know of OBJ via the action of at least one of its senses (e.g. sight, hearing, smell, etc). Precisely what tangible aspects of OBJ have been apprehended depend on the sensory modality used (see predicates which have #$perceives as a #$genlPreds). For example, if (#$sees AGENT OBJ), then AGENT knows of some visual aspects of OBJ. Whereas if (#$smells AGENT OBJ), then AGENT knows of some olfactory aspects of OBJ. Only tangible things, #$PhysicalEvents or #$PartiallyTangibles, can be perceived") ;;; #$perfect (#$isa #$perfect #$IntangibleObjectPredicate) (#$isa #$perfect #$BinaryPredicate) (#$arg1Isa #$perfect #$EnglishWord) (#$arg2Isa #$perfect #$CharacterString) (#$comment #$perfect "(#$perfect WORD STRING) means that STRING is the perfect verb form of WORD. This form is also known as the past participle. The regular perfect verb form is often the same as the past tense verb form. Verbs in the Cyc lexicon will have a #$perfect entry only if they are irregular. Regular forms are generated by the morphology component. Regular example: `helped'. Irregular example: `eaten'.") ;;; #$performanceLevel (#$isa #$performanceLevel #$QuintaryPredicate) (#$isa #$performanceLevel #$FunctionalPredicate) (#$arg1Isa #$performanceLevel #$SomethingExisting) (#$arg2Isa #$performanceLevel #$Event) (#$arg3Isa #$performanceLevel #$ActorSlot) (#$arg4Isa #$performanceLevel #$ScriptPerformanceAttributeType) (#$arg4Genl #$performanceLevel #$ScriptPerformanceAttribute) (#$arg5Isa #$performanceLevel #$GenericAttribute) (#$comment #$performanceLevel "This predicate relates performers to particular individual actions. (#$performanceLevel OBJ EVT ROLE PERF-ATT LEVEL) means that the individual OBJ plays the role ROLE in the action EVT, and does so with the performance attribute PERF-ATT to the degree LEVEL. Such an assertion expresses actual performance in a particular action; for example, (#$performanceLevel #$Joe DiggingHole54001 #$performedBy #$Strength #$Low) means Joe exerted a low level of strength while digging that particular hole. This does not imply much about Joe's potential to exert strength, about strength required in general for hole-digging, etc., it just talks about that one single event. To talk about typical or expected performance, use #$skillLevel.") ;;; #$performedBy (#$isa #$performedBy #$ActorSlot) (#$genlPreds #$performedBy #$doneBy) (#$genlPreds #$performedBy #$deliberateActors) (#$arg1Isa #$performedBy #$Action) (#$arg2Isa #$performedBy #$Agent) (#$comment #$performedBy "The predicate #$performedBy relates an event to an agent who performs it deliberately, which in Cyc means, intentionally and volitionally. (#$performedBy ACT DOER) means that the agent DOER deliberately does the action ACT. DOER must be an #$Agent. For example, (#$performedBy #$AssassinationOfPresidentLincoln #$JohnWilkesBooth). If ACT has multiple performers, ACT will be #$performedBy each of them. See also #$deliberateActors, #$doneBy.") ;;; #$performedByPart (#$isa #$performedByPart #$ActorSlot) (#$genlPreds #$performedByPart #$performedBy) (#$arg1Isa #$performedByPart #$Action) (#$arg2Isa #$performedByPart #$Organization) (#$comment #$performedByPart "(#$performedByPart ACT ORG) means that the #$Organization ORG is considered to be the performer of the #$Action ACT, though in fact only some subordinate part of ORG (i.e., a member or a sub-organization), rather than all of the organization, is directly involved in ACT. For example, (#$performedByPart OperationDesertStorm USArmy) since only certain divisions of the US Army participated in Operation Desert Storm.") ;;; #$perpendicularObjects (#$not (#$isa #$perpendicularObjects #$TransitiveBinaryPredicate)) (#$isa #$perpendicularObjects #$IrreflexiveBinaryPredicate) (#$isa #$perpendicularObjects #$SymmetricBinaryPredicate) (#$isa #$perpendicularObjects #$SpatialPredicate) (#$genlInverse #$perpendicularObjects #$perpendicularObjects) (#$arg1Isa #$perpendicularObjects #$PartiallyTangible) (#$arg2Isa #$perpendicularObjects #$PartiallyTangible) (#$comment #$perpendicularObjects "(#$perpendicularObjects OBJ1 OBJ2) means that the longest axis of OBJ1 is perpendicular to the longest axis of OBJ2.") ;;; #$perpendicularVectors (#$isa #$perpendicularVectors #$SymmetricBinaryPredicate) (#$not (#$isa #$perpendicularVectors #$TransitiveBinaryPredicate)) (#$not (#$isa #$perpendicularVectors #$ReflexiveBinaryPredicate)) (#$not (#$isa #$perpendicularVectors #$IrreflexiveBinaryPredicate)) (#$genlInverse #$perpendicularVectors #$perpendicularVectors) (#$arg1Isa #$perpendicularVectors #$VectorInterval) (#$arg2Isa #$perpendicularVectors #$VectorInterval) (#$comment #$perpendicularVectors "(#$perpendicularVectors VECTOR1 VECTOR2) means that VECTOR1 is perpendicular to VECTOR2. E.g., (#$perpendicularVectors #$SouthEast-Directly #$SouthWest-Directly), (#$perpendicularVectors #$East-Directly #$North-Directly).") ;;; #$perpetrator (#$isa #$perpetrator #$IrreflexiveBinaryPredicate) (#$isa #$perpetrator #$AsymmetricBinaryPredicate) (#$isa #$perpetrator #$ActorSlot) (#$genlPreds #$perpetrator #$performedBy) (#$arg1Isa #$perpetrator #$Action) (#$arg2Isa #$perpetrator #$SocialBeing) (#$comment #$perpetrator "The #$Agent(s) that performed this possibly criminal act.") ;;; #$phoneNumberText (#$isa #$phoneNumberText #$BinaryPredicate) (#$arg1Isa #$phoneNumberText #$ContactLocation) (#$arg2Isa #$phoneNumberText #$PhoneNumber) (#$comment #$phoneNumberText "The predicate #$phoneNumberText is used to relate a telephone number to a contact location. (#$phoneNumberText LOC NUM) means NUM is a string denoting (one of) the phone number(s) of the #$ContactLocation LOC.") ;;; #$physicalDecompositions (#$isa #$physicalDecompositions #$PhysicalPartPredicate) (#$isa #$physicalDecompositions #$TransitiveBinaryPredicate) (#$isa #$physicalDecompositions #$AntiSymmetricBinaryPredicate) (#$isa #$physicalDecompositions #$ReflexiveBinaryPredicate) (#$isa #$physicalDecompositions #$CotemporalObjectsSlot) (#$genlPreds #$physicalDecompositions #$parts) (#$genlPreds #$physicalDecompositions #$spatiallyIntersects) (#$genlPreds #$physicalDecompositions #$cotemporal) (#$genlInverse #$physicalDecompositions #$inRegion) (#$arg1Isa #$physicalDecompositions #$PartiallyTangible) (#$arg2Isa #$physicalDecompositions #$PartiallyTangible) (#$comment #$physicalDecompositions "(#$physicalDecompositions WHOLE PART) -- PART is any spatial part or decomposition of WHOLE. PART may be discontinuous, diffused throughout the object, discrete and identifiable, etc.") ;;; #$physicalExtent (#$isa #$physicalExtent #$FunctionalSlot) (#$isa #$physicalExtent #$TransitiveBinaryPredicate) (#$isa #$physicalExtent #$AntiSymmetricBinaryPredicate) (#$not (#$isa #$physicalExtent #$ReflexiveBinaryPredicate)) (#$not (#$isa #$physicalExtent #$IrreflexiveBinaryPredicate)) (#$genlPreds #$physicalExtent #$parts) (#$arg1Isa #$physicalExtent #$CompositeTangibleAndIntangibleObject) (#$arg2Isa #$physicalExtent #$PartiallyTangible) (#$comment #$physicalExtent "(#$physicalExtent WHOLE PART) means that PART is the physical part of the #$CompositeTangibleAndIntangibleObject WHOLE.") ;;; #$physicalParts (#$isa #$physicalParts #$PhysicalPartPredicate) (#$isa #$physicalParts #$TransitiveBinaryPredicate) (#$isa #$physicalParts #$ReflexiveBinaryPredicate) (#$isa #$physicalParts #$AntiSymmetricBinaryPredicate) (#$isa #$physicalParts #$CotemporalObjectsSlot) (#$isa #$physicalParts #$PhysicalFeatureDescribingPredicate) (#$genlPreds #$physicalParts #$physicalDecompositions) (#$genlPreds #$physicalParts #$cotemporal) (#$arg1Isa #$physicalParts #$PartiallyTangible) (#$arg2Isa #$physicalParts #$PartiallyTangible) (#$comment #$physicalParts "(#$physicalParts WHOLE PART) -- WHOLE is a physical object and PART is one of its distinct, non-diffuse, identifiable parts, such as the relationship between a car and its wheels or bumpers. The #$physicalParts of an object include only those spatial decompositions which are distinct, identifiable parts.") ;;; #$physicalPortions (#$isa #$physicalPortions #$PhysicalPartPredicate) (#$isa #$physicalPortions #$CotemporalObjectsSlot) (#$genlPreds #$physicalPortions #$physicalDecompositions) (#$genlPreds #$physicalPortions #$cotemporal) (#$arg1Isa #$physicalPortions #$PartiallyTangible) (#$arg2Isa #$physicalPortions #$PartiallyTangible) (#$comment #$physicalPortions "(#$physicalPortions ?WHOLE ?PART) means ?PART is a representative spatial chunk of ?WHOLE. Every intrinsic property which is true of ?WHOLE should be true of ?PART. Spatial parts of ?WHOLE which are not representative of the whole would be #$physicalParts or #$physicalDecompositions , not #$physicalPortions. For example, the SpaghettiSauce001 which is part of SpaghettiDinner001 is a #$physicalParts of the dinner. A #$physicalPortions of the dinner would include some sauce, some noodles, some parmesan cheese, etc. - parts of all the #$constituents. This is the spatial analog of #$timeSlices (not #$subEvents).") ;;; #$physicalQuarters (#$isa #$physicalQuarters #$SubProcessSlot) (#$arg1Isa #$physicalQuarters #$Organization) (#$arg2Isa #$physicalQuarters #$ConstructionArtifact) (#$comment #$physicalQuarters "The predicate #$physicalQuarters is used to relate an organization to the building(s) it occupies. (#$physicalQuarters ORG BLDG) means that the #$Organization ORG is located in the #$ConstructionArtifact BLDG, which may consist of one or more buildings, rooms, offices, etc.") ;;; #$physicalStructuralAttributes (#$isa #$physicalStructuralAttributes #$BinaryPredicate) (#$isa #$physicalStructuralAttributes #$TangibleSubstancePredicate) (#$genlPreds #$physicalStructuralAttributes #$hasAttributes) (#$arg1Isa #$physicalStructuralAttributes #$PartiallyTangible) (#$arg2Isa #$physicalStructuralAttributes #$PhysicalStructuralAttribute) (#$comment #$physicalStructuralAttributes "(#$physicalStructuralAttributes OBJ ATT) means that the physical structure of the tangible object OBJ is (at least partially) determined or described by its attribute ATT. See also #$PhysicalStructuralAttribute.") ;;; #$physicalStructuralIntegrity (#$isa #$physicalStructuralIntegrity #$BinaryPredicate) (#$isa #$physicalStructuralIntegrity #$TangibleSubstancePredicate) (#$arg1Isa #$physicalStructuralIntegrity #$PartiallyTangible) (#$arg2Isa #$physicalStructuralIntegrity #$GenericAttribute) (#$comment #$physicalStructuralIntegrity "(#$physicalStructuralIntegrity SUBST DEGREE) means that the tangible object SUBST has DEGREE ability to maintain its physical structure intact in the face of various forces. DEGREE is a #$GenericAttribute. The #$physicalStructuralIntegrity of an object may be inferred from some of its other physical attributes; e.g., something with the #$physicalStructuralAttributes #$Granular has a #$Low degree of #$physicalStructuralIntegrity; things whose #$stateOfMatter is #$LiquidStateOfMatter have #$VeryLow #$physicalStructuralIntegrity.") ;;; #$pipeEndsAtCavity (#$isa #$pipeEndsAtCavity #$ConnectionPredicate) (#$isa #$pipeEndsAtCavity #$SpatialPredicate) (#$isa #$pipeEndsAtCavity #$AsymmetricBinaryPredicate) (#$genlPreds #$pipeEndsAtCavity #$connectedTo-Rigidly) (#$genlPreds #$pipeEndsAtCavity #$pathTerminus) (#$arg1Isa #$pipeEndsAtCavity #$Pipe-GenericConduit) (#$arg2Isa #$pipeEndsAtCavity #$PartiallyTangible) (#$comment #$pipeEndsAtCavity "(#$pipeEndsAtCavity PIPE CAV) means that PIPE is a #$Pipe-GenericConduit that joins the larger-diameter #$Cavity CAV at a #$PipeEndToCavityJunction, allowing flow or access between them. The flange where a water pipe enters a water tank is one example, as is the junction of the #$Esophagus and the #$Stomach in animals. See also the collection #$PipeEndToCavityJunction.") ;;; #$pipesDirectlyConnected (#$isa #$pipesDirectlyConnected #$ConnectionPredicate) (#$isa #$pipesDirectlyConnected #$SymmetricBinaryPredicate) (#$genlPreds #$pipesDirectlyConnected #$connectedTo) (#$genlInverse #$pipesDirectlyConnected #$pipesDirectlyConnected) (#$arg1Isa #$pipesDirectlyConnected #$Pipe-GenericConduit) (#$arg2Isa #$pipesDirectlyConnected #$Pipe-GenericConduit) (#$comment #$pipesDirectlyConnected "(pipesDirectlyConnected PIPE1 PIPE2) means that there is a #$JunctionOfPipes connecting two #$Pipe-GenericConduits, PIPE1 to PIPE2, (or else they are #$endToEndConnected) allowing flow of #$FluidTangibleThings between them.") ;;; #$plaintiffs (#$isa #$plaintiffs #$IrreflexiveBinaryPredicate) (#$isa #$plaintiffs #$AsymmetricBinaryPredicate) (#$isa #$plaintiffs #$ActorSlot) (#$genlPreds #$plaintiffs #$litigants) (#$arg1Isa #$plaintiffs #$Trial) (#$arg2Isa #$plaintiffs #$Agent) (#$comment #$plaintiffs "(plaintiffs ARG1 ARG2) means that the agent ARG2 is the complaining party (the party bringing an accusation of wrong-doing) in the lawsuit ARG1.") ;;; #$plural (#$isa #$plural #$IntangibleObjectPredicate) (#$isa #$plural #$BinaryPredicate) (#$arg1Isa #$plural #$EnglishWord) (#$arg2Isa #$plural #$CharacterString) (#$comment #$plural "(#$plural WORD STRING) means that STRING is the plural noun form of WORD. For example, the #$plural form of #$Hit-TheWord is `hits', and the plural form of #$Goose-TheWord is `geese'.") ;;; #$pointClosedSubSystems (#$isa #$pointClosedSubSystems #$ReflexiveBinaryPredicate) (#$isa #$pointClosedSubSystems #$TransitiveBinaryPredicate) (#$isa #$pointClosedSubSystems #$AntiSymmetricBinaryPredicate) (#$genlPreds #$pointClosedSubSystems #$subPathSystems) (#$arg1Isa #$pointClosedSubSystems #$Thing) (#$arg2Isa #$pointClosedSubSystems #$Thing) (#$comment #$pointClosedSubSystems "(#$pointClosedSubSystems SYS SUBSYS) means that the path system SUBSYS is a subsystem of the path system SYS (i.e., (#$subPathSystems SYS SUBSYS) holds) and SUBSYS 'preserves' all points in SYS that are on links in SUBSYS, i.e., if LINK is a link in SUBSYS (and hence is a link in SYS) and X is a point in SYS and is on LINK, then X must be a point in SUBSYS.") ;;; #$pointInSystem (#$isa #$pointInSystem #$AsymmetricBinaryPredicate) (#$arg1Isa #$pointInSystem #$Thing) (#$arg2Isa #$pointInSystem #$Thing) (#$comment #$pointInSystem "(#$pointInSystem POINT SYS) means that POINT is an instance of #$Thing, SYS is an instance of #$PathSystem, and POINT is a 'point' on a path in SYS or is a 'node' in SYS. Note that for each path system SYS there is at least one POINT such that (#$pointInSystem POINT SYS) holds. For any path system SYS, the set of all points in SYS has an important subset, the set of all 'nodes' in SYS. See #$nodeInSystem for the difference between nodes and points that are not nodes in a path system. Note that in some cases (such as making a 'closed world' or talking about different systems), using (#$PointFn SYS) to denote the set of all points in a path system SYS is more convenient than using the predicate #$pointInSystem.") ;;; #$pointOfContact (#$isa #$pointOfContact #$TernaryPredicate) (#$arg1Isa #$pointOfContact #$Agent) (#$arg2Isa #$pointOfContact #$ContactLocationType) (#$arg2Genl #$pointOfContact #$ContactLocation) (#$arg3Isa #$pointOfContact #$ContactLocation) (#$comment #$pointOfContact "The predicate #$pointOfContact (#$pointOfContact AGENT LOCTYPE LOC) means the #$Agent AGENT has as its LOCTYPE (a #$ContactLocationType such as #$Workplace, #$HumanResidence, #$BillingLocation, etc.) a particular #$ContactLocation LOC, where that agent can be contacted. Typically, LOC is a complete address, i.e., it is not a generic location such as Austin, TX.") ;;; #$pointOfContactInfo (#$isa #$pointOfContactInfo #$QuaternaryPredicate) (#$arg1Isa #$pointOfContactInfo #$Agent) (#$arg2Isa #$pointOfContactInfo #$ContactLocationType) (#$arg2Genl #$pointOfContactInfo #$ContactLocation) (#$arg3Isa #$pointOfContactInfo #$BinaryPredicate) (#$arg4Isa #$pointOfContactInfo #$Thing) (#$comment #$pointOfContactInfo "The predicate #$pointOfContactInfo allows us to characterize a string of information as belonging to a certain kind of contact location for a particular person, without actually reifying those contact locations. (#$pointOfContactInfo AGENT LOC-TYPE INFO-TYPE STRING) means that AGENT's contact locations of type LOC-TYPE (e.g., #$Workplace) have STRING as their contact address of INFO-TYPE (e.g., #$phoneNumberText, #$faxNumberText, #$addressText). For example, to say that Keith Goolsbey's home phone number is 512-123-4567, we write: (#$pointOfContactInfo #$Goolsbey #$HumanResidence #$phoneNumberText ``(512) 123-4567''). Note: the disadvantage of this shorthand method is that all of AGENT's contact locations of the type LOC-TYPE are assumed to have the same STRING of INFO-TYPE.") ;;; #$pointingToward (#$not (#$isa #$pointingToward #$AsymmetricBinaryPredicate)) (#$not (#$isa #$pointingToward #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$pointingToward #$SymmetricBinaryPredicate)) (#$not (#$isa #$pointingToward #$TransitiveBinaryPredicate)) (#$isa #$pointingToward #$BinaryPredicate) (#$isa #$pointingToward #$SpatialPredicate) (#$arg1Isa #$pointingToward #$PartiallyTangible) (#$arg2Isa #$pointingToward #$PartiallyTangible) (#$comment #$pointingToward "(#$pointingToward OBJ1 OBJ2) means that OBJ1 has a pointing axis and that its axis points toward OBJ2. A pointing axis is ascribed to objects that have directionality (e.g., a gun, a projectile, an arrow, an extended finger).") ;;; #$pointsOfContact (#$isa #$pointsOfContact #$BinaryPredicate) (#$arg1Isa #$pointsOfContact #$Agent) (#$arg2Isa #$pointsOfContact #$ContactLocation) (#$comment #$pointsOfContact "The predicate #$pointsOfContact indicates the places at which a particular agent can be reached. (#$pointsOfContact AGENT LOC) means that the #$Agent AGENT can be contacted at the #$ContactLocation LOC.") ;;; #$porosityOfObject (#$isa #$porosityOfObject #$IntervalBasedQuantitySlot) (#$isa #$porosityOfObject #$TangibleObjectPredicate) (#$isa #$porosityOfObject #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$porosityOfObject #$PartiallyTangible) (#$arg2Isa #$porosityOfObject #$Porosity) (#$comment #$porosityOfObject "(#$porosityOfObject OBJ DEGREE) means that the tangible object OBJ has the degree of #$Porosity DEGREE.") ;;; #$portalConnectsRegions (#$isa #$portalConnectsRegions #$TernaryPredicate) (#$arg1Isa #$portalConnectsRegions #$Portal) (#$arg2Isa #$portalConnectsRegions #$PartiallyTangible) (#$arg3Isa #$portalConnectsRegions #$PartiallyTangible) (#$comment #$portalConnectsRegions "(#$portalConnectsRegions PORTAL HERE THERE) means that the regions HERE and THERE each contain PORTAL as a physical part.") ;;; #$portalHasCovering (#$isa #$portalHasCovering #$CotemporalObjectsSlot) (#$isa #$portalHasCovering #$PhysicalPartPredicate) (#$genlPreds #$portalHasCovering #$physicalParts) (#$arg1Isa #$portalHasCovering #$Portal) (#$arg2Isa #$portalHasCovering #$PortalCovering) (#$comment #$portalHasCovering "A general predicate for relating instances of portal to their coverings. Specpreds include #$doorwayHasCovering and #$windowHasCovering.") ;;; #$posForms (#$isa #$posForms #$BinaryPredicate) (#$arg1Isa #$posForms #$EnglishWord) (#$arg2Isa #$posForms #$LinguisticObjectType) (#$arg2Genl #$posForms #$SpeechPart) (#$comment #$posForms "The predicate #$posForms is used to indicate the different parts of speech that a particular English word has associated with it. (#$posForms WORD POS) means that the #$EnglishWord WORD has a form that can serve as the #$SpeechPart POS. For example, #$Dot-TheWord has forms for both #$SimpleNoun and #$Verb. Forms of a word used for different parts of speech may or may not differ from each other in sound and/or spelling. To find out, or to specify, the string that represents a particular POS form of a specific word, use #$partOfSpeech.") ;;; #$positiveVestedInterest (#$isa #$positiveVestedInterest #$BinaryPredicate) (#$not (#$isa #$positiveVestedInterest #$TransitiveBinaryPredicate)) (#$not (#$isa #$positiveVestedInterest #$SymmetricBinaryPredicate)) (#$not (#$isa #$positiveVestedInterest #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$positiveVestedInterest #$AsymmetricBinaryPredicate)) (#$not (#$isa #$positiveVestedInterest #$ReflexiveBinaryPredicate)) (#$not (#$isa #$positiveVestedInterest #$IrreflexiveBinaryPredicate)) (#$arg1Isa #$positiveVestedInterest #$Agent) (#$arg2Isa #$positiveVestedInterest #$TemporalThing) (#$comment #$positiveVestedInterest "(#$positiveVestedInterest AGT OBJ) means #$Agent AGT has a positive interest in the object OBJ or in the good fortune of OBJ. Generally, AGT will be helped or pleased by the preservation or enhancement of OBJ. Note: the restriction of OBJ to #$TemporalThing means that it would be incorrect to use this predicate to say that Douglas Adams has a #$positiveVestedInterest in the number 42. Rather, what he has a vested interest in is public popularity and faddism focusing on that number. A fad is a #$TemporalThing, but the number 42 isn't.") ;;; #$possesses (#$isa #$possesses #$Predicate) (#$arg1Isa #$possesses #$Agent) (#$arg2Isa #$possesses #$SomethingExisting) (#$comment #$possesses "(#$possesses AGENT OBJECT) means that OBJECT is in the physical possession of AGENT. Compare with #$owns.") ;;; #$postActors (#$isa #$postActors #$ActorSlot) (#$genlPreds #$postActors #$actors) (#$genlInverse #$postActors #$endsAfterEndingOf) (#$arg1Isa #$postActors #$Event) (#$arg2Isa #$postActors #$SomethingExisting) (#$comment #$postActors "The predicate #$postActors is used to indicate a participant that continues to exist after a particular event. (#$postActors EVENT OBJECT) means that OBJECT exists after EVENT ends. It makes no commitment about OBJECT's condition before or during EVENT. #$postActors is a very general element of #$ActorSlot; it subsumes #$outputsCreated, #$doneBy, and many others.") ;;; #$postConfiguration (#$isa #$postConfiguration #$BinaryPredicate) (#$genlInverse #$postConfiguration #$startsAfterEndingOf) (#$arg1Isa #$postConfiguration #$Event) (#$arg2Isa #$postConfiguration #$StaticSituation) (#$comment #$postConfiguration "(#$postConfiguration EVT CONFIG) means CONFIG is a #$Configuration that begins immediately after the action EVT ends, and is directly (probably causally) related to EVT. See #$postEvents and #$preConfiguration for related predicates.") (#$overlappingExternalConcept #$postConfiguration #$SENSUS-Information1997 "POSTCONDITION") ;;; #$postEvents (#$isa #$postEvents #$Role) (#$isa #$postEvents #$ComplexTemporalRelation) (#$isa #$postEvents #$TransitiveBinaryPredicate) (#$isa #$postEvents #$AsymmetricBinaryPredicate) (#$genlInverse #$postEvents #$startsAfterEndingOf) (#$arg1Isa #$postEvents #$Event) (#$arg2Isa #$postEvents #$Event) (#$comment #$postEvents "This predicate relates one event to another that follows it. (#$postEvents BEFORE AFTER) implies two things: (1) BEFORE occurs strictly before AFTER; i.e., AFTER starts after BEFORE has ended; i.e., (#$startsAfterEndingOf AFTER BEFORE); and (2) BEFORE and AFTER are significantly relevant to each other. This required `relevance' of the two arguments to each other is difficult to formalize but often intuitively clearcut. Often, e.g., AFTER is caused by BEFORE.") ;;; #$postalCodeOfAddress (#$isa #$postalCodeOfAddress #$FunctionalSlot) (#$arg1Isa #$postalCodeOfAddress #$ContactLocation) (#$arg2Isa #$postalCodeOfAddress #$PostalCode) (#$comment #$postalCodeOfAddress "The predicate #$postalCodeOfAddress maps from a particular element of #$ContactLocation to a corresponding element of #$PostalCode. (#$postalCodeOfAddress LOC PC) means that the location LOC has the #$PostalCode PC. For example, if LOC had the address: P.O. Box 1677-B, New York, NY, 10014, PC would be the string `10014'. See also #$ContactLocation.") ;;; #$postureOfAnimal (#$isa #$postureOfAnimal #$ShapeDescribingPredicate) (#$isa #$postureOfAnimal #$FunctionalSlot) (#$genlPreds #$postureOfAnimal #$hasAttributes) (#$arg1Isa #$postureOfAnimal #$Animal) (#$arg2Isa #$postureOfAnimal #$Posture) (#$comment #$postureOfAnimal "(#$postureOfAnimal ?AN ?POS) means that the #$Animal ?AN is in the #$Posture ?POS. #$Postures are types of attributes that describe bodily configurations and/or orientations of #$Animals. See #$Posture for examples.") ;;; #$preActors (#$isa #$preActors #$IrreflexiveBinaryPredicate) (#$isa #$preActors #$ActorSlot) (#$isa #$preActors #$AsymmetricBinaryPredicate) (#$genlPreds #$preActors #$actors) (#$genlPreds #$preActors #$startsAfterStartingOf) (#$arg1Isa #$preActors #$Event) (#$arg2Isa #$preActors #$SomethingExisting) (#$comment #$preActors "The predicate #$preActors is used to indicate a participant that pre-exists a particular event. (#$preActors EVENT OBJECT) means that OBJECT exists before EVENT begins. It makes no commitment about OBJECT's condition during or after EVENT. #$preActors is a very general #$ActorSlot, subsuming #$doneBy, #$objectActedOn, #$objectMoving, and many others.") ;;; #$preConfiguration (#$isa #$preConfiguration #$IrreflexiveBinaryPredicate) (#$isa #$preConfiguration #$AsymmetricBinaryPredicate) (#$isa #$preConfiguration #$AntiTransitiveBinaryPredicate) (#$genlPreds #$preConfiguration #$startsAfterEndingOf) (#$arg1Isa #$preConfiguration #$Event) (#$arg2Isa #$preConfiguration #$StaticSituation) (#$comment #$preConfiguration "(#$preConfiguration EVT CONFIG) means CONFIG is an element of #$Configuration that holds just prior to the start of EVT, and CONFIG is directly related to EVT. The required `salience' of the two arguments to each other is difficult to formalize but usually intuitively clearcut. Commonly, CONFIG and EVT share many of the same objects involved in various roles, and there is often a causal connection as well. For instance, the configuration CONFIG might be somehow `taken apart' by event EVT, might `trigger' EVT, etc.") (#$overlappingExternalConcept #$preConfiguration #$SENSUS-Information1997 "PRECONDITION") ;;; #$presenter (#$isa #$presenter #$IrreflexiveBinaryPredicate) (#$isa #$presenter #$AsymmetricBinaryPredicate) (#$isa #$presenter #$ActorSlot) (#$genlPreds #$presenter #$socialParticipants) (#$arg1Isa #$presenter #$SocialGathering) (#$arg2Isa #$presenter #$Person) (#$comment #$presenter "(#$presenter GATHERING PERSON) means that PERSON speaks to a set of audience members who have a role in GATHERING.") ;;; #$prettyName (#$isa #$prettyName #$BinaryPredicate) (#$arg1Isa #$prettyName #$CycIndexedTerm) (#$arg2Isa #$prettyName #$CycSystemString) (#$comment #$prettyName "(#$prettyName TERM STRING) means that STRING is the English word or expression (sequence of words) commonly used to refer to the #$Cyc term TERM. The predicate #$prettyName is used by the code which generates CycL to English paraphrases, but its applicability is not restricted to this use.") ;;; #$primaryFunction (#$isa #$primaryFunction #$TernaryPredicate) (#$genlPreds #$primaryFunction #$intendedBehaviorCapable) (#$arg1Isa #$primaryFunction #$Artifact) (#$arg2Isa #$primaryFunction #$Collection) (#$arg2Genl #$primaryFunction #$Situation) (#$arg3Isa #$primaryFunction #$Role) (#$comment #$primaryFunction "The predicate #$primaryFunction is used to indicate what an artifact was primarily designed to do. (#$primaryFunction ART SITTYPE ROLE) means that the primary function of the #$Artifact OBJ is to serve as described by ROLE in situations of the type SITTYPE. Examples: the #$primaryFunction of instances of #$MammographyFacility is to be the #$providerOfService in instances of #$MammographicBreastCancerScreening; the #$primaryFunction of a pump is to be the #$providerOfMotiveForce in instances of #$TransportingGoods in which liquids are transported. Note: in the #$SimpleDeviceFunctioningMt, it is assumed that every #$PhysicalDevice has only one primary function.") ;;; #$primitiveAttributeTypes (#$isa #$primitiveAttributeTypes #$BinaryPredicate) (#$arg1Isa #$primitiveAttributeTypes #$CompositeAttributeType) (#$arg2Isa #$primitiveAttributeTypes #$PrimitiveAttributeType) (#$comment #$primitiveAttributeTypes "The Cyc predicate #$primitiveAttributeTypes is used to relate a type of complex attribute to its basic components. (#$primitiveAttributeTypes COMP PRIM) means that PRIM is an element of #$PrimitiveAttributeType that makes up the #$CompositeAttributeType, COMP. PRIM can be thought of as one axis for the composite scale. For example, hue, intensity, and saturation are each a primitive scale for the composite attribute `color'. Another case: #$Speed is a primitive component of the composite attribute #$VelocityVector.") ;;; #$products (#$isa #$products #$ActorSlot) (#$genlPreds #$products #$outputs) (#$arg1Isa #$products #$CreationOrDestructionEvent) (#$arg2Isa #$products #$PartiallyTangible) (#$comment #$products "(#$products EV OBJ) means that OBJ is one of the intended outputs of event EV. For unintended outputs, see #$byProducts. For a particular EV and OBJ, it will not be true that both (#$products EV OBJ) and (#$byProducts EV OBJ).") ;;; #$programUsed (#$isa #$programUsed #$IrreflexiveBinaryPredicate) (#$isa #$programUsed #$AsymmetricBinaryPredicate) (#$isa #$programUsed #$ActorSlot) (#$genlPreds #$programUsed #$instrument-Generic) (#$genlPreds #$programUsed #$unchangedActors) (#$arg1Isa #$programUsed #$Action) (#$arg2Isa #$programUsed #$ComputerProgram) (#$comment #$programUsed "(#$programUsed EV PROG) means that PROG is the computer program used in the action EV.") ;;; #$propositionalInfoAbout (#$isa #$propositionalInfoAbout #$BinaryPredicate) (#$arg1Isa #$propositionalInfoAbout #$PropositionalInformationThing) (#$arg2Isa #$propositionalInfoAbout #$Thing) (#$comment #$propositionalInfoAbout "(#$propositionalInfoAbout ?MT ?OBJ) means that the #$PropositionalInformationThing ?MT is 'about' ?OBJ, i.e. it is a #$Microtheory with assertions concerning this object. For example, a microtheory which is the propositional content of a portrait of #$GeorgeWashington might only have #$GeorgeWashington as the ?OBJ of this predicate.") ;;; #$propositionsPerceived (#$isa #$propositionsPerceived #$BinaryPredicate) (#$arg1Isa #$propositionsPerceived #$Perceiving) (#$arg2Isa #$propositionsPerceived #$CycFormula) (#$comment #$propositionsPerceived "(#$propositionsPerceived PERCEIVING PROP) means that in the #$Perceiving event PERCEIVING, the perceiver mentally grasps the proposition(s) PROP. E.g., ten people witness a particular car crash, and yet each one gets their own particular set of propositions which they later can relate to the police; there are ten separate #$Perceivings in this case, and each one has its own unique set of #$propositionsPerceived.") ;;; #$providerOfMotiveForce (#$isa #$providerOfMotiveForce #$ActorSlot) (#$genlPreds #$providerOfMotiveForce #$preActors) (#$arg1Isa #$providerOfMotiveForce #$MovementEvent) (#$arg2Isa #$providerOfMotiveForce #$PartiallyTangible) (#$comment #$providerOfMotiveForce "(#$providerOfMotiveForce ACT OBJ) means that OBJ provides, through its expenditure of energy, a significant fraction of the physical force required to make ACT happen. For example, if ACT is an element of #$PedalingABicycle, OBJ will be the person who is operating the bike. Another example: in the use of a belt sanding tool, there will be two values for #$providerOfMotiveForce, the electric sander and the person operating the sander. In that case, although force is transmitted and applied through the sandpaper, the paper doesn't count as a #$providerOfMotiveForce, because it only transmits force and does not itself expend energy. Note that inferences involving this constant require that every #$providerOfMotiveForce be a whole object, not just a part of an object. For example:(#$implies (#$and (#$isa ?LOCO #$LocomotionEvent) (#$providerOfMotiveForce ?LOCO ?OBJ)) (#$objectMoving ?LOCO ?OBJ)) or (#$implies (#$and (#$isa ?LOC #$LocomotionEvent) (#$providerOfMotiveForce ?LOC ?PROV)) (#$doneBy ?LOC ?PROV)) or (#$domainAssumptions #$ManualHumanActivitiesMt (#$forAll ?U (#$forAll ?PERS (#$implies (#$and (#$isa ?U #$Action) (#$providerOfMotiveForce ?U ?PERS)) (#$isa ?PERS #$Person)))))).") ;;; #$providerOfService (#$isa #$providerOfService #$ActorSlot) (#$isa #$providerOfService #$AsymmetricBinaryPredicate) (#$isa #$providerOfService #$IrreflexiveBinaryPredicate) (#$genlPreds #$providerOfService #$deliberateActors) (#$genlPreds #$providerOfService #$preActors) (#$genlPreds #$providerOfService #$performedBy) (#$arg1Isa #$providerOfService #$ServiceEvent) (#$arg2Isa #$providerOfService #$Agent) (#$comment #$providerOfService "The Cyc predicate #$providerOfService is used to relate a service to the agent that provides it. (#$providerOfService SEVT AGT) means that the #$ServiceEvent SEVT is performed or provided by the #$Agent AGT. Typically, AGT acts in order to serve the #$recipientOfService in SEVT.") ;;; #$purpose-RST (#$isa #$purpose-RST #$RSTRelation) (#$isa #$purpose-RST #$AsymmetricBinaryPredicate) (#$arg1Isa #$purpose-RST #$LinguisticObject) (#$arg2Isa #$purpose-RST #$LinguisticObject) (#$comment #$purpose-RST "The discourse relation that holds between two segments of text when ARG1 specifies something which is initiated with the purpose of achieving ARG2. #$purpose-RST is agnostic as to volition; see also #$volitionalCause-RST.") (#$synonymousExternalConcept #$purpose-RST #$SENSUS-Information1997 "RST-PURPOSE") ;;; #$purposeInEvent (#$isa #$purposeInEvent #$ModalRelationship) (#$isa #$purposeInEvent #$TernaryPredicate) (#$arg1Isa #$purposeInEvent #$Agent) (#$arg2Isa #$purposeInEvent #$PurposefulAction) (#$arg3Isa #$purposeInEvent #$Goal) (#$comment #$purposeInEvent "(#$purposeInEvent AGT EVT G) means that the agent AGT is taking part in event EVT because (1) AGT wants G to become true, and also (2) AGT expects and believes that EVT occurring will (help) make G true.") (#$overlappingExternalConcept #$purposeInEvent #$SENSUS-Information1997 "PURPOSE") ;;; #$quotientUnits (#$isa #$quotientUnits #$TernaryPredicate) (#$isa #$quotientUnits #$BookkeepingPredicate) (#$arg1Isa #$quotientUnits #$UnitOfMeasure) (#$arg2Isa #$quotientUnits #$UnitOfMeasure) (#$arg3Isa #$quotientUnits #$UnitOfMeasure) (#$comment #$quotientUnits "The Cyc predicate #$quotientUnits is used to state what measurement units should be used for the quotient of two physical quantities, given the units measuring the dividend and divisor. (#$quotientUnits UM-1 UM-2 QUOT-UM) means that the value of (#$QuotientFn (UM-1 x) (UM-2 y)) should be given in the units QUOT-UM. Examples: (#$quotientUnits #$Newton #$SquareMeter #$Pascal-UnitOfPressure); (#$quotientUnits #$Unity #$DaysDuration #$PerDay); (#$quotientUnits (#$Micro #$Gram) (#$Milli #$Liter) #$MicrogramsPerMilliliter). See also #$UnitOfMeasure, #$QuotientFn.") ;;; #$radius (#$isa #$radius #$IntervalBasedQuantitySlot) (#$isa #$radius #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$radius #$PartiallyTangible) (#$arg2Isa #$radius #$Distance) (#$comment #$radius "The radius of an object with a circular shape.") ;;; #$raininessOfRegion (#$isa #$raininessOfRegion #$IntervalBasedQuantitySlot) (#$genlPreds #$raininessOfRegion #$hasAttributes) (#$arg1Isa #$raininessOfRegion #$OutdoorLocation) (#$arg2Isa #$raininessOfRegion #$Raininess) (#$comment #$raininessOfRegion "(#$raininessOfRegion LOC DEGREE) indicates the intensity with which it is raining at the #$OutdoorLocation LOC. (If it is not raining at LOC, it will be the case that (#$raininessOfRegion LOC (#$NoAmountFn #$Raininess)).)") ;;; #$rateOfRotationOfObject (#$isa #$rateOfRotationOfObject #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$rateOfRotationOfObject #$PartiallyTangible) (#$arg2Isa #$rateOfRotationOfObject #$RateOfRotation) (#$comment #$rateOfRotationOfObject "#$rateOfRotationOfObject relates an instance of #$PartiallyTangible to the rate of change of its physical component's angular separation from a reference vector as measured from a point of origin.") ;;; #$recipientOfInfo (#$isa #$recipientOfInfo #$ActorSlot) (#$genlPreds #$recipientOfInfo #$informationDestination) (#$arg1Isa #$recipientOfInfo #$InformationTransferEvent) (#$arg2Isa #$recipientOfInfo #$Agent) (#$comment #$recipientOfInfo "The predicate #$recipientOfInfo is used to indicate who receives information in a particular communication event. (#$recipientOfInfo TRANSFER RECIP) means that the information transferred in the #$InformationTransferEvent TRANSFER is received by the #$Agent RECIP. After TRANSFER, RECIP understands or conceives of the information transferred in TRANSFER; Cyc does NOT conclude that s/he #$knows the information or counts it among his/her #$beliefs, because RECIP might not believe it. In receiving the information transferred, RECIP may be acting intentionally or unintentionally. See also #$infoTransferred.") (#$synonymousExternalConcept #$recipientOfInfo #$SENSUS-Information1997 "ADDRESSEE") ;;; #$recipientOfService (#$isa #$recipientOfService #$ActorSlot) (#$genlPreds #$recipientOfService #$beneficiary) (#$genlPreds #$recipientOfService #$preActors) (#$genlPreds #$recipientOfService #$postActors) (#$arg1Isa #$recipientOfService #$ServiceEvent) (#$arg2Isa #$recipientOfService #$Agent) (#$comment #$recipientOfService "(#$recipientOfService ACT AGNT) means the #$Agent AGNT is the recipient of the #$ServiceEvent ACT. The service is performed on, for, or to AGNT, and AGNT is correspondingly affected by it.") ;;; #$reciprocalTransfers (#$isa #$reciprocalTransfers #$AntiTransitiveBinaryPredicate) (#$isa #$reciprocalTransfers #$SymmetricBinaryPredicate) (#$genlInverse #$reciprocalTransfers #$reciprocalTransfers) (#$arg1Isa #$reciprocalTransfers #$TransferringPossession) (#$arg2Isa #$reciprocalTransfers #$TransferringPossession) (#$comment #$reciprocalTransfers "(#$reciprocalTransfers ?T1 ?T2) means that ?T1 and ?T2 are transfers of possession done in exchange for each other. They are part of some #$ExchangeOfUserRights.") ;;; #$reductionOfPathSystems (#$isa #$reductionOfPathSystems #$TransitiveBinaryPredicate) (#$isa #$reductionOfPathSystems #$AntiSymmetricBinaryPredicate) (#$genlPreds #$reductionOfPathSystems #$linkClosedSubSystems) (#$arg1Isa #$reductionOfPathSystems #$Thing) (#$arg2Isa #$reductionOfPathSystems #$MultiGraph) (#$comment #$reductionOfPathSystems "(#$reductionOfPathSystems SYS RED) means that (i) every node in SYS is a node in RED, (ii) every point in RED is a node in RED (and hence a node in SYS), and (iii) (#$linkClosedSubSystems SYS RED) holds. It is easy to see that when (#$reductionOfPathSystems SYS RED) holds, RED must be an instance of #$MultiGraph. But RED is not only a multi-graph, it is THE multi-graph that underlies the path system SYS, i.e., the only difference between SYS and RED is that SYS is obtainable by adding to RED some points that are on a link in RED between the end-nodes.") ;;; #$referredServiceProvider (#$isa #$referredServiceProvider #$IrreflexiveBinaryPredicate) (#$isa #$referredServiceProvider #$AsymmetricBinaryPredicate) (#$isa #$referredServiceProvider #$ActorSlot) (#$genlPreds #$referredServiceProvider #$providerOfService) (#$arg1Isa #$referredServiceProvider #$ServiceEvent) (#$arg2Isa #$referredServiceProvider #$Agent) (#$comment #$referredServiceProvider "The agent ARG2 who provides the service ARG1 was referred by another agent.") ;;; #$relationType (#$isa #$relationType #$TernaryPredicate) (#$isa #$relationType #$RuleMacroPredicate) (#$arg1Isa #$relationType #$BinaryPredicate) (#$arg2Isa #$relationType #$Collection) (#$arg3Isa #$relationType #$Collection) (#$comment #$relationType "(#$relationType SLOT COL1 COL2) means that, for every instance of COL1 (INS1), there is some instance of COL2 (INS2) such that (SLOT INS1 INS2) holds. #$relationType is thus redundant with a huge set of commonly-occurring rules. By having this predicate (along with an axiom defining it, and, eventually, coded support for quick inferencing with it), those rules can be stated more tersely and reasoning at the collection level is possible.") ;;; #$relationTypeCount (#$isa #$relationTypeCount #$QuaternaryPredicate) (#$arg1Isa #$relationTypeCount #$BinaryPredicate) (#$arg2Isa #$relationTypeCount #$Collection) (#$arg3Isa #$relationTypeCount #$Collection) (#$arg4Isa #$relationTypeCount #$NonNegativeInteger) (#$comment #$relationTypeCount "(#$relationTypeCount SLOT COL1 COL2 NUM) means that, for every instance of COL1 (INS1) there are exactly NUM instances of COL2 (INS2, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS1 INS3), ..., hold. Thus, (#$relationTypeCount #$anatomicalParts #$Dog #$Leg 4) means simply `dogs have four legs'.") ;;; #$relationTypeMax (#$isa #$relationTypeMax #$QuaternaryPredicate) (#$arg1Isa #$relationTypeMax #$BinaryPredicate) (#$arg2Isa #$relationTypeMax #$Collection) (#$arg3Isa #$relationTypeMax #$Collection) (#$arg4Isa #$relationTypeMax #$PositiveInteger) (#$comment #$relationTypeMax "(#$relationTypeMax SLOT COL1 COL2 NUM) means that, for every instance of COL1 (INS1) there are at most NUM instances of COL2 (INS2, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS1 INS3), ..., hold. Thus (#$relationTypeMax #$anatomicalParts #$Mammal #$Leg 4) would mean `every mammal has at most four legs'.") ;;; #$relationTypeMin (#$isa #$relationTypeMin #$QuaternaryPredicate) (#$arg1Isa #$relationTypeMin #$BinaryPredicate) (#$arg2Isa #$relationTypeMin #$Collection) (#$arg3Isa #$relationTypeMin #$Collection) (#$arg4Isa #$relationTypeMin #$NonNegativeInteger) (#$comment #$relationTypeMin "(#$relationTypeMin SLOT COL1 COL2 NUM) means that, for every instance of COL1 (INS1) there are at least NUM instances of COL2 (INS2, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS1 INS3), ..., hold. Thus (#$relationTypeMin #$subEvents #$EatingEvent #$Swallowing 1) would mean `every eating event has at least one swallowing sub-event'.") ;;; #$relatives (#$isa #$relatives #$FamilyRelationSlot) (#$isa #$relatives #$SymmetricBinaryPredicate) (#$isa #$relatives #$ReflexiveBinaryPredicate) (#$not (#$isa #$relatives #$TransitiveBinaryPredicate)) (#$genlInverse #$relatives #$relatives) (#$arg1Isa #$relatives #$Animal) (#$arg2Isa #$relatives #$Animal) (#$comment #$relatives "(#$relatives PERSON1 PERSON2) means PERSON2 is some relative of PERSON1, howsoever the relationship is traced, biologically or through custom, rearing or adoption.") (#$comment #$relatives "(#$relatives ANIM1 ANIM2) means ANIM2 is some biological relative of ANIM1.") ;;; #$rents (#$isa #$rents #$CotemporalObjectsSlot) (#$genlPreds #$rents #$cotemporal) (#$arg1Isa #$rents #$Agent) (#$arg2Isa #$rents #$PartiallyTangible) (#$comment #$rents "The predicate #$rents relates an agent to something that s/he is renting. (#$rents AGT OBJ) means that the #$Agent AGT is renting the object (possibly a piece of real estate) OBJ from another, unspecified agent. AGT is the borrower, renter, lessee or tenant. AGT has temporary use and enjoyment of OBJ, for a charge. See also #$TemporaryUserRightsAgreement, #$TemporaryChangeOfUserRights, #$Renting.") ;;; #$representsAgentInEvent (#$isa #$representsAgentInEvent #$TernaryPredicate) (#$arg1Isa #$representsAgentInEvent #$Agent) (#$arg2Isa #$representsAgentInEvent #$Agent) (#$arg3Isa #$representsAgentInEvent #$TemporalThing) (#$comment #$representsAgentInEvent "ARG1 represents ARG2 in the event ARG3. ARG2 often has multiple entries, when ARG1 is appointed to represent the group's interests.") ;;; #$representsAgentToAgent (#$isa #$representsAgentToAgent #$TernaryPredicate) (#$arg1Isa #$representsAgentToAgent #$Agent) (#$arg2Isa #$representsAgentToAgent #$Agent) (#$arg3Isa #$representsAgentToAgent #$Agent) (#$comment #$representsAgentToAgent "(#$representsAgentToAgent AGENT1 AGENT2 AGENT3) means that in in dealings with AGENT3, AGENT1 represents AGENT2. For example, if Joe Terwilliger is a salesman working for IBM, and is their sales rep to NASA, then we could represent that by asserting to Cyc (#$representsAgentToAgent JoeTerwilliger IBM #$NASA).") ;;; #$requiredArg1Pred (#$isa #$requiredArg1Pred #$BinaryPredicate) (#$isa #$requiredArg1Pred #$RuleMacroPredicate) (#$arg1Isa #$requiredArg1Pred #$Collection) (#$arg2Isa #$requiredArg1Pred #$Predicate) (#$comment #$requiredArg1Pred "(#$requiredArg1Pred COL PRED) means that for every instance INS of COL, there exists some X1..Xn-1 such that (PRED INS X1 .. Xn-1), where the #$arity of PRED is n.") ;;; #$requiredArg2Pred (#$isa #$requiredArg2Pred #$RuleMacroPredicate) (#$isa #$requiredArg2Pred #$BinaryPredicate) (#$arg1Isa #$requiredArg2Pred #$Collection) (#$arg2Isa #$requiredArg2Pred #$Predicate) (#$comment #$requiredArg2Pred "(#$requiredArg2Pred COL PRED) means that for every instance INS of COL, there exists some X1..Xn-1 such that (PRED X INS .. Xn-1), where the #$arity of PRED is n. ") ;;; #$requiresForRole (#$isa #$requiresForRole #$TernaryPredicate) (#$arg1Isa #$requiresForRole #$Situation) (#$arg2Isa #$requiresForRole #$Collection) (#$arg3Isa #$requiresForRole #$Role) (#$comment #$requiresForRole "(#$requiresForRole ?SIT ?COL ?ROLE) means that success of the #$Situation ?SIT depends upon the existence of an element of the collection ?COL playing the role ?ROLE in ?SIT.") ;;; #$resemblesInAttribute (#$isa #$resemblesInAttribute #$TernaryPredicate) (#$arg1Isa #$resemblesInAttribute #$Thing) (#$arg2Isa #$resemblesInAttribute #$Thing) (#$arg3Isa #$resemblesInAttribute #$AttributeType) (#$comment #$resemblesInAttribute "(#$resemblesInAttribute THING1 THING2 ATTRIBUTE) means that the two things THING1 and THING2 resemble each other in their values of the #$AttributeType ATTRIBUTE. Here 'resembles' means has a 'close' or similar value in that attribute -- what this means, and what the standard of closeness or similarity is, depends on the context. See also #$identicalInAttribute and #$differentInAttribute.") (#$overlappingExternalConcept #$resemblesInAttribute #$SENSUS-Information1997 "SIMILARITY") ;;; #$residenceOfOrganization (#$isa #$residenceOfOrganization #$BinaryPredicate) (#$arg1Isa #$residenceOfOrganization #$Organization) (#$arg2Isa #$residenceOfOrganization #$GeographicalRegion) (#$comment #$residenceOfOrganization "The predicate #$residenceOfOrganization indicates the geographical location of a particular organization's main offices. (#$residenceOfOrganization ORG GEOGREG) means that the #$Organization ORG has its chief office at the location GEOGREG. GEOGREG is typically a #$City but may be a larger or smaller #$GeographicalRegion. For example, the #$residenceOfOrganization of the #$UnitedStatesFederalGovernment is the #$CityOfWashingtonDC.") ;;; #$residesInDwelling (#$isa #$residesInDwelling #$CotemporalObjectsSlot) (#$genlPreds #$residesInDwelling #$cotemporal) (#$arg1Isa #$residesInDwelling #$Animal) (#$arg1Isa #$residesInDwelling #$Person) (#$arg2Isa #$residesInDwelling #$ShelterConstruction) (#$arg2Isa #$residesInDwelling #$HumanResidence) (#$comment #$residesInDwelling "(#$residesInDwelling X SHELT) means the #$Person or #$Animal X resides or lives in the #$ShelterConstruction SHELT -- meaning the place where it sleeps, spends much of its time, lays its eggs, a place which it cleans and maintains and repairs, a place it defends against intrusion, etc. A person or animal may reside in more than one dwelling. For example, a person on a camping trip might #$residesInDwelling some tent, during that trip, and at the same time it would still be true that he or she #$residesInDwelling their `normal' apartment or house. See also #$occupantsAre and #$residesInRegion. A couple other notes: Note: #$residesInDwelling is not the same as legal domicile, though often of course they coincide. Note: #$residesInDwelling is not appropriate for one animal living in/on another, as a parasite or symbiote. A more general predicate, #$objectFoundInLocation, would be the appropriate one to use for the case of a #$Flea living on a #$Dog.") ;;; #$residesInRegion (#$isa #$residesInRegion #$CotemporalObjectsSlot) (#$genlPreds #$residesInRegion #$cotemporal) (#$arg1Isa #$residesInRegion #$Animal) (#$arg2Isa #$residesInRegion #$GeographicalRegion) (#$comment #$residesInRegion "(#$residesInRegion X REG) means the individual #$Animal or #$Person X lives or resides primarily in the #$GeographicalRegion REG. Notice that everyone (every first argument X) is likely to have many different regions REG that make the assertion (#$residesInRegion X REG) true. E.g., Karen resides in Austin, in Texas, in the United States, in North America, etc. See also #$residesInDwelling.") ;;; #$resistanceOfObject (#$isa #$resistanceOfObject #$TangibleObjectPredicate) (#$isa #$resistanceOfObject #$IntervalBasedQuantitySlot) (#$arg1Isa #$resistanceOfObject #$PartiallyTangible) (#$arg2Isa #$resistanceOfObject #$ElectricalResistance) (#$comment #$resistanceOfObject "(#$resistanceOfObject OBJ DEGREE) means that the tangible object OBJ has this DEGREE of #$ElectricalResistance. A lower value of DEGREE indicates OBJ is a better conductor, i.e., one that conducts with less energy lost to heat.") ;;; #$resistanceToBioDeterioration (#$isa #$resistanceToBioDeterioration #$IntervalBasedQuantitySlot) (#$isa #$resistanceToBioDeterioration #$TangibleObjectPredicate) (#$isa #$resistanceToBioDeterioration #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$resistanceToBioDeterioration #$PartiallyTangible) (#$arg2Isa #$resistanceToBioDeterioration #$BioDeteriorationResistance) (#$comment #$resistanceToBioDeterioration "(#$resistanceToBioDeterioration OBJ DEGREE) means that the tangible object OBJ has the indicated DEGREE of resistance to biological deterioration.") ;;; #$resistanceToCorrosion (#$isa #$resistanceToCorrosion #$IntervalBasedQuantitySlot) (#$isa #$resistanceToCorrosion #$TangibleObjectPredicate) (#$isa #$resistanceToCorrosion #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$resistanceToCorrosion #$PartiallyTangible) (#$arg2Isa #$resistanceToCorrosion #$CorrosionResistance) (#$comment #$resistanceToCorrosion "(#$resistanceToCorrosion OBJ DEGREE) means that the tangible object OBJ has the stated DEGREE of #$CorrosionResistance. The higher DEGREE is, the less readily OBJ will corrode.") ;;; #$resistanceToRadiation (#$isa #$resistanceToRadiation #$IntervalBasedQuantitySlot) (#$isa #$resistanceToRadiation #$TangibleObjectPredicate) (#$isa #$resistanceToRadiation #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$resistanceToRadiation #$PartiallyTangible) (#$arg2Isa #$resistanceToRadiation #$RadiationResistance) (#$comment #$resistanceToRadiation "(#$resistanceToRadiation OBJ DEGREE) indicates how resistant a tangible object OBJ is to radiation. A higher DEGREE of resistance means that an object is less penetrable by #$ElectromagneticRadiation.") ;;; #$responseTo (#$isa #$responseTo #$BinaryPredicate) (#$arg1Isa #$responseTo #$Acknowledging-CommunicationAct) (#$arg2Isa #$responseTo #$PropositionalInformationThing) (#$comment #$responseTo "(#$responseTo ?ACT ?PIT) means that ?ACT is an acknowledging act to signify receipt of the abstract information ?PIT that is being acknowledged and to indicate a response. The ?ACT may be an #$Accepting-CommunicationAct or a #$Rejecting-CommunicationAct, or several others. Some may be combinations, e.g. David may accept part of #$Wanda's order (say the part about cleaning the kitchen) but not the other part (say cleaning the bathroom). See also #$acknowledgedAct which relates the two acts directly.") ;;; #$resultGenl (#$isa #$resultGenl #$BinaryPredicate) (#$isa #$resultGenl #$FunctionalSlot) (#$isa #$resultGenl #$RuleMacroPredicate) (#$arg1Isa #$resultGenl #$CollectionDenotingFunction) (#$arg2Isa #$resultGenl #$Collection) (#$comment #$resultGenl "The Cyc predicate #$resultGenl is used to specify that a certain collection is a superset of the value returned by a particular collection-denoting function. (#$resultGenl CDF COL) means that when the #$CollectionDenotingFunction CDF is applied to its legal number and type of arguments, the result will be a subset of the #$Collection COL -- i.e., the #$genls of (CDF ARG1 [ARG2 ... ARGN]) will include COL. Examples: (#$resultGenl #$UsingAFn #$Action), i.e., `every using of a [particular kind of] object is an action'; (#$resultGenl #$AttemptingFn #$PurposefulAction), i.e., `every attempt [at a specific action] is a purposeful act'; (#$resultGenl #$BachelorsDegreeInFn #$BachelorsDegree), i.e., `every bachelor's degree [in some subject] is a bachelor's degree'; (#$resultGenl #$JointTypeBetweenFn #$Connection), i.e., `every joint [between specific things] is a connection'. See also #$resultIsa.") ;;; #$resultIsa (#$isa #$resultIsa #$RuleMacroPredicate) (#$isa #$resultIsa #$IntangibleObjectPredicate) (#$isa #$resultIsa #$BinaryPredicate) (#$arg1Isa #$resultIsa #$Relationship) (#$arg2Isa #$resultIsa #$Collection) (#$comment #$resultIsa "The Cyc predicate #$resultIsa is used to indicate that the value returned by a particular function is an element of a certain Cyc collection. In other words, when FUNC is applied to its legal number of valid arguments in a non-atomic term, that resultant term is an element of the #$Collection COL; Thus, (#$resultIsa FUNC COL) means that applications of FUNC return elements of COL; i.e., (#$resultIsa FUNC COL) implies that (#$isa (FUNC ARG1 [ARG2 ... ARGN]) COL). For example, since legal uses of #$PlusFn always return a quantity, (#$resultIsa #$PlusFn #$ScalarInterval) is asserted in Cyc. Another example: because Cyc knows that (#$resultIsa #$GovernmentFn #$RegionalGovernment), Cyc concludes that the government of France is an element of #$RegionalGovernment; i.e., (#$isa (#$GovernmentFn #$France) #$RegionalGovernment). See also #$resultGenl.") ;;; #$resultantMentalObjects (#$isa #$resultantMentalObjects #$BinaryPredicate) (#$arg1Isa #$resultantMentalObjects #$Perceiving) (#$arg2Isa #$resultantMentalObjects #$MentalObject) (#$comment #$resultantMentalObjects "(#$resultantMentalObjects PEVT PERCEPT) means that during the #$Perceiving event PEVT, the perceiver acquires the #$MentalObject PERCEPT (i.e., feeling some emotion, deducing some conclusion, observing some facts, etc.)") ;;; #$rightsGranted (#$isa #$rightsGranted #$BinaryPredicate) (#$arg1Isa #$rightsGranted #$ChangeInUserRights) (#$arg2Isa #$rightsGranted #$UserRightsAttribute) (#$comment #$rightsGranted "This predicate is used to indicate what #$UserRightsAttributes are acquired in events which bring about a #$ChangeInUserRights. (#$rightsGranted EVENT URA) means that in the #$ChangeInUserRights EVENT, the #$UserRightsAttribute URA is granted (to some agent). For example, (#$rightsGranted ''LouisianaPurchase'' #$ExclusiveUserRights), since no country other than the USA could then claim it as one of their territories. If EVENT is a #$Buying event, then almost always both (#$rightsGranted EVENT #$FullUseRights) and (#$rightsGranted EVENT #$ExclusiveUserRights) are true.") ;;; #$rigidityOfObject (#$isa #$rigidityOfObject #$PhysicalAttributeDescriptionSlot) (#$isa #$rigidityOfObject #$TangibleObjectPredicate) (#$isa #$rigidityOfObject #$IntervalBasedQuantitySlot) (#$arg1Isa #$rigidityOfObject #$PartiallyTangible) (#$arg2Isa #$rigidityOfObject #$Rigidity) (#$comment #$rigidityOfObject "(#$rigidityOfObject OBJ DEGREE) means that the tangible object OBJ has this DEGREE of #$Rigidity. A higher DEGREE of #$Rigidity means more force is required to change the shape of OBJ than for a lower DEGREE.") ;;; #$rotationallyConnectedTo (#$not (#$isa #$rotationallyConnectedTo #$TransitiveBinaryPredicate)) (#$isa #$rotationallyConnectedTo #$IrreflexiveBinaryPredicate) (#$isa #$rotationallyConnectedTo #$SymmetricBinaryPredicate) (#$isa #$rotationallyConnectedTo #$ConnectionPredicate) (#$isa #$rotationallyConnectedTo #$SpatialPredicate) (#$genlPreds #$rotationallyConnectedTo #$connectedTo) (#$genlInverse #$rotationallyConnectedTo #$rotationallyConnectedTo) (#$arg1Isa #$rotationallyConnectedTo #$SolidTangibleThing) (#$arg2Isa #$rotationallyConnectedTo #$SolidTangibleThing) (#$comment #$rotationallyConnectedTo "(#$rotationallyConnectedTo OBJ1 OBJ2) means that OBJ1 and OBJ2 are connected in such a way that rotational motion, and only rotational motion, can happen between them. The rotational motion may be fully or partially rotational. Non-rotational movement between two rotationally connected objects at their connection point can occur only if the connection is broken, deformed, or disassembled. Positive examples: Femurs are rotationally connected to hips, doors are rotationally connected to door frames, doorknobs are rotationally connected to doors, and propellers are rotationally connected to airplanes; in computer trackballs the ball is rotationally connected to the housing. Negative examples: a planet orbiting around a star (they are not connected). Cf. #$MovingInACircle.") ;;; #$salientAssertions (#$isa #$salientAssertions #$BinaryPredicate) (#$isa #$salientAssertions #$MetaKnowledgePredicate) (#$arg1Isa #$salientAssertions #$ReifiableTerm) (#$arg2Isa #$salientAssertions #$Assertion) (#$comment #$salientAssertions "(#$salientAssertions ?TERM ?ASSERTION) means that some #$Cyclist has deemed it useful to mark ?ASSERTION as one of the assertions which is most useful to examine when trying to figure out the intended meaning of ?TERM. Statements using #$salientAssertions are wholly intended for human consumption; they are not used by Cyc's inference engine in any way. ")